﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using Enter.Common;
using Enter.DataProxy.Mail.Base;

namespace Enter.Factory
{
    public sealed class DataFactory
    {
        private static readonly string path = "Enter.DataProxy.Mail";//System.Configuration.ConfigurationManager.AppSettings["Enter.DataProxy.Mail"];

        private static object CreateObject(string path, string CacheKey)
        {
            object objType = CacheHelper.Get(CacheKey);
            if (objType == null)
            {
                try
                {
                    objType = Assembly.Load(path).CreateInstance(CacheKey);
                    CacheHelper.Set(CacheKey, objType);
                }
                catch { }

            }
            return objType;
        }
        /// <summary>
        /// 通过反射机制，实例化Sys_Operator接口对象。
        /// </summary>
        ///<returns>Sys_Operator接口对象</returns>
        public static ISys_OperatorManager Create_Sys_Operator()
        {
            string CacheKey = path + ".Sys_OperatorManager";
            object objType = CreateObject(path, CacheKey);
            return (ISys_OperatorManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化Sys_PopMenuList接口对象。
        /// </summary>
        ///<returns>Sys_PopMenuList接口对象</returns>
        public static ISys_PopMenuListManager Create_Sys_PopMenuList()
        {
            string CacheKey = path + ".Sys_PopMenuListManager";
            object objType = CreateObject(path, CacheKey);
            return (ISys_PopMenuListManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化Sys_Role接口对象。
        /// </summary>
        ///<returns>Sys_Role接口对象</returns>
        public static ISys_RoleManager Create_Sys_Role()
        {
            string CacheKey = path + ".Sys_RoleManager";
            object objType = CreateObject(path, CacheKey);
            return (ISys_RoleManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T101_Goods接口对象。
        /// </summary>
        ///<returns>T101_Goods接口对象</returns>
        public static IT101_GoodsManager Create_T101_Goods()
        {
            string CacheKey = path + ".T101_GoodsManager";
            object objType = CreateObject(path, CacheKey);
            return (IT101_GoodsManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T102_GoodInfo接口对象。
        /// </summary>
        ///<returns>T102_GoodInfo接口对象</returns>
        public static IT102_GoodInfoManager Create_T102_GoodInfo()
        {
            string CacheKey = path + ".T102_GoodInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT102_GoodInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T103_Goods_Item接口对象。
        /// </summary>
        ///<returns>T103_Goods_Item接口对象</returns>
        public static IT103_Goods_ItemManager Create_T103_Goods_Item()
        {
            string CacheKey = path + ".T103_Goods_ItemManager";
            object objType = CreateObject(path, CacheKey);
            return (IT103_Goods_ItemManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T104_GoodImges接口对象。
        /// </summary>
        ///<returns>T104_GoodImges接口对象</returns>
        public static IT104_GoodImgesManager Create_T104_GoodImges()
        {
            string CacheKey = path + ".T104_GoodImgesManager";
            object objType = CreateObject(path, CacheKey);
            return (IT104_GoodImgesManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T105_GoodClass接口对象。
        /// </summary>
        ///<returns>T105_GoodClass接口对象</returns>
        public static IT105_GoodClassManager Create_T105_GoodClass()
        {
            string CacheKey = path + ".T105_GoodClassManager";
            object objType = CreateObject(path, CacheKey);
            return (IT105_GoodClassManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T106_GoodClassProperty接口对象。
        /// </summary>
        ///<returns>T106_GoodClassProperty接口对象</returns>
        public static IT106_GoodClassPropertyManager Create_T106_GoodClassProperty()
        {
            string CacheKey = path + ".T106_GoodClassPropertyManager";
            object objType = CreateObject(path, CacheKey);
            return (IT106_GoodClassPropertyManager)objType;
        }
        /// <summary>
        /// 通过反射机制，实例化T106_GoodClassStockProperty接口对象。
        /// </summary>
        ///<returns>T106_GoodClassStockProperty接口对象</returns>
        public static IT106_GoodClassStockPropertyManager Create_T106_GoodClassStockProperty()
        {
            string CacheKey = path + ".T106_GoodClassStockPropertyManager";
            object objType = CreateObject(path, CacheKey);
            return (IT106_GoodClassStockPropertyManager)objType;
        }
        /// <summary>
        /// 通过反射机制，实例化T106_GoodClassStockProperty_Item接口对象。
        /// </summary>
        ///<returns>T106_GoodClassStockProperty_Item接口对象</returns>
        public static IT106_GoodClassStockProperty_ItemManager Create_T106_GoodClassStockProperty_Item()
        {
            string CacheKey = path + ".T106_GoodClassStockProperty_ItemManager";
            object objType = CreateObject(path, CacheKey);
            return (IT106_GoodClassStockProperty_ItemManager)objType;
        }

        /// <summary>
        /// 通过反射机制，实例化T107_GoodActive接口对象。
        /// </summary>
        ///<returns>T107_GoodActive接口对象</returns>
        public static IT107_GoodActiveManager Create_T107_GoodActive()
        {
            string CacheKey = path + ".T107_GoodActiveManager";
            object objType = CreateObject(path, CacheKey);
            return (IT107_GoodActiveManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T108_GoodCheakInfo接口对象。
        /// </summary>
        ///<returns>T108_GoodCheakInfo接口对象</returns>
        public static IT108_GoodCheakInfoManager Create_T108_GoodCheakInfo()
        {
            string CacheKey = path + ".T108_GoodCheakInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT108_GoodCheakInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T109_GoodBrand接口对象。
        /// </summary>
        ///<returns>T109_GoodBrand接口对象</returns>
        public static IT109_GoodBrandManager Create_T109_GoodBrand()
        {
            string CacheKey = path + ".T109_GoodBrandManager";
            object objType = CreateObject(path, CacheKey);
            return (IT109_GoodBrandManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T110_GoodBrandIndex接口对象。
        /// </summary>
        ///<returns>T110_GoodBrandIndex接口对象</returns>
        public static IT110_GoodBrandIndexManager Create_T110_GoodBrandIndex()
        {
            string CacheKey = path + ".T110_GoodBrandIndexManager";
            object objType = CreateObject(path, CacheKey);
            return (IT110_GoodBrandIndexManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T111_GoodClassSpecials接口对象。
        /// </summary>
        ///<returns>T111_GoodClassSpecials接口对象</returns>
        public static IT111_GoodClassSpecialsManager Create_T111_GoodClassSpecials()
        {
            string CacheKey = path + ".T111_GoodClassSpecialsManager";
            object objType = CreateObject(path, CacheKey);
            return (IT111_GoodClassSpecialsManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T112_GoodBrandSpecials接口对象。
        /// </summary>
        ///<returns>T112_GoodBrandSpecials接口对象</returns>
        public static IT112_GoodBrandSpecialsManager Create_T112_GoodBrandSpecials()
        {
            string CacheKey = path + ".T112_GoodBrandSpecialsManager";
            object objType = CreateObject(path, CacheKey);
            return (IT112_GoodBrandSpecialsManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T113_Good_Property接口对象。
        /// </summary>
        ///<returns>T113_Good_Property接口对象</returns>
        public static IT113_Good_PropertyManager Create_T113_Good_Property()
        {
            string CacheKey = path + ".T113_Good_PropertyManager";
            object objType = CreateObject(path, CacheKey);
            return (IT113_Good_PropertyManager)objType;
        }
        /// <summary>
        /// 通过反射机制，实例化T114_GoodBrand_Item接口对象。
        /// </summary>
        ///<returns>T114_GoodBrand_Item接口对象</returns>
        public static IT114_GoodBrand_ItemManager Create_T114_GoodBrand_Item()
        {
            string CacheKey = path + ".T114_GoodBrand_ItemManager";
            object objType = CreateObject(path, CacheKey);
            return (IT114_GoodBrand_ItemManager)objType;
        }
        /// <summary>
        /// 通过反射机制，实例化T115_GoodBrand_Img接口对象。
        /// </summary>
        ///<returns>T115_GoodBrand_Img接口对象</returns>
        public static IT115_GoodBrand_ImgManager Create_T115_GoodBrand_Img()
        {
            string CacheKey = path + ".T115_GoodBrand_ImgManager";
            object objType = CreateObject(path, CacheKey);
            return (IT115_GoodBrand_ImgManager)objType;
        }
        /// <summary>
        /// 通过反射机制，实例化T116_GoodClassProperty_Value接口对象。
        /// </summary>
        ///<returns>T116_GoodClassProperty_Value接口对象</returns>
        public static IT116_GoodClassProperty_ValueManager Create_T116_GoodClassProperty_Value()
        {
            string CacheKey = path + ".T116_GoodClassProperty_ValueManager";
            object objType = CreateObject(path, CacheKey);
            return (IT116_GoodClassProperty_ValueManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T201_User接口对象。
        /// </summary>
        ///<returns>T201_User接口对象</returns>
        public static IT201_UserManager Create_T201_User()
        {
            string CacheKey = path + ".T201_UserManager";
            object objType = CreateObject(path, CacheKey);
            return (IT201_UserManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T202_UserInfo接口对象。
        /// </summary>
        ///<returns>T202_UserInfo接口对象</returns>
        public static IT202_UserInfoManager Create_T202_UserInfo()
        {
            string CacheKey = path + ".T202_UserInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT202_UserInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T203_UserAddress接口对象。
        /// </summary>
        ///<returns>T203_UserAddress接口对象</returns>
        public static IT203_UserAddressManager Create_T203_UserAddress()
        {
            string CacheKey = path + ".T203_UserAddressManager";
            object objType = CreateObject(path, CacheKey);
            return (IT203_UserAddressManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T204_UserLoginInfo接口对象。
        /// </summary>
        ///<returns>T204_UserLoginInfo接口对象</returns>
        public static IT204_UserLoginInfoManager Create_T204_UserLoginInfo()
        {
            string CacheKey = path + ".T204_UserLoginInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT204_UserLoginInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T205_UserGoodComment接口对象。
        /// </summary>
        ///<returns>T205_UserGoodComment接口对象</returns>
        public static IT205_UserGoodCommentManager Create_T205_UserGoodComment()
        {
            string CacheKey = path + ".T205_UserGoodCommentManager";
            object objType = CreateObject(path, CacheKey);
            return (IT205_UserGoodCommentManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T206_UserTradeComment接口对象。
        /// </summary>
        ///<returns>T206_UserTradeComment接口对象</returns>
        public static IT206_UserTradeCommentManager Create_T206_UserTradeComment()
        {
            string CacheKey = path + ".T206_UserTradeCommentManager";
            object objType = CreateObject(path, CacheKey);
            return (IT206_UserTradeCommentManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T207_UserPic接口对象。
        /// </summary>
        ///<returns>T207_UserPic接口对象</returns>
        public static IT207_UserPicManager Create_T207_UserPic()
        {
            string CacheKey = path + ".T207_UserPicManager";
            object objType = CreateObject(path, CacheKey);
            return (IT207_UserPicManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T208_UserTradeInfo接口对象。
        /// </summary>
        ///<returns>T208_UserTradeInfo接口对象</returns>
        public static IT208_UserTradeInfoManager Create_T208_UserTradeInfo()
        {
            string CacheKey = path + ".T208_UserTradeInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT208_UserTradeInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T209_UserPower接口对象。
        /// </summary>
        ///<returns>T209_UserPower接口对象</returns>
        public static IT209_UserPowerManager Create_T209_UserPower()
        {
            string CacheKey = path + ".T209_UserPowerManager";
            object objType = CreateObject(path, CacheKey);
            return (IT209_UserPowerManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T210_UserPreferential接口对象。
        /// </summary>
        ///<returns>T210_UserPreferential接口对象</returns>
        public static IT210_UserPreferentialManager Create_T210_UserPreferential()
        {
            string CacheKey = path + ".T210_UserPreferentialManager";
            object objType = CreateObject(path, CacheKey);
            return (IT210_UserPreferentialManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T211_UserShopCollection接口对象。
        /// </summary>
        ///<returns>T211_UserShopCollection接口对象</returns>
        public static IT211_UserShopCollectionManager Create_T211_UserShopCollection()
        {
            string CacheKey = path + ".T211_UserShopCollectionManager";
            object objType = CreateObject(path, CacheKey);
            return (IT211_UserShopCollectionManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T212_UserGoodCollection接口对象。
        /// </summary>
        ///<returns>T212_UserGoodCollection接口对象</returns>
        public static IT212_UserGoodCollectionManager Create_T212_UserGoodCollection()
        {
            string CacheKey = path + ".T212_UserGoodCollectionManager";
            object objType = CreateObject(path, CacheKey);
            return (IT212_UserGoodCollectionManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T213_UserGoodReturn接口对象。
        /// </summary>
        ///<returns>T213_UserGoodReturn接口对象</returns>
        public static IT213_UserGoodReturnManager Create_T213_UserGoodReturn()
        {
            string CacheKey = path + ".T213_UserGoodReturnManager";
            object objType = CreateObject(path, CacheKey);
            return (IT213_UserGoodReturnManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T301_Order_Main接口对象。
        /// </summary>
        ///<returns>T301_Order_Main接口对象</returns>
        public static IT301_Order_MainManager Create_T301_Order_Main()
        {
            string CacheKey = path + ".T301_Order_MainManager";
            object objType = CreateObject(path, CacheKey);
            return (IT301_Order_MainManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T302_Order_Items接口对象。
        /// </summary>
        ///<returns>T302_Order_Items接口对象</returns>
        public static IT302_Order_ItemsManager Create_T302_Order_Items()
        {
            string CacheKey = path + ".T302_Order_ItemsManager";
            object objType = CreateObject(path, CacheKey);
            return (IT302_Order_ItemsManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T303_Order_Cart接口对象。
        /// </summary>
        ///<returns>T303_Order_Cart接口对象</returns>
        public static IT303_Order_CartManager Create_T303_Order_Cart()
        {
            string CacheKey = path + ".T303_Order_CartManager";
            object objType = CreateObject(path, CacheKey);
            return (IT303_Order_CartManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T304_Order_Pay接口对象。
        /// </summary>
        ///<returns>T304_Order_Pay接口对象</returns>
        public static IT304_Order_PayManager Create_T304_Order_Pay()
        {
            string CacheKey = path + ".T304_Order_PayManager";
            object objType = CreateObject(path, CacheKey);
            return (IT304_Order_PayManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T401_Shop接口对象。
        /// </summary>
        ///<returns>T401_Shop接口对象</returns>
        public static IT401_ShopManager Create_T401_Shop()
        {
            string CacheKey = path + ".T401_ShopManager";
            object objType = CreateObject(path, CacheKey);
            return (IT401_ShopManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T402_ShopInfo接口对象。
        /// </summary>
        ///<returns>T402_ShopInfo接口对象</returns>
        public static IT402_ShopInfoManager Create_T402_ShopInfo()
        {
            string CacheKey = path + ".T402_ShopInfoManager";
            object objType = CreateObject(path, CacheKey);
            return (IT402_ShopInfoManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T403_ShopRating接口对象。
        /// </summary>
        ///<returns>T403_ShopRating接口对象</returns>
        public static IT403_ShopRatingManager Create_T403_ShopRating()
        {
            string CacheKey = path + ".T403_ShopRatingManager";
            object objType = CreateObject(path, CacheKey);
            return (IT403_ShopRatingManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T404_ShopTradeComment接口对象。
        /// </summary>
        ///<returns>T404_ShopTradeComment接口对象</returns>
        public static IT404_ShopTradeCommentManager Create_T404_ShopTradeComment()
        {
            string CacheKey = path + ".T404_ShopTradeCommentManager";
            object objType = CreateObject(path, CacheKey);
            return (IT404_ShopTradeCommentManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T405_ShopGoodClass接口对象。
        /// </summary>
        ///<returns>T405_ShopGoodClass接口对象</returns>
        public static IT405_ShopGoodClassManager Create_T405_ShopGoodClass()
        {
            string CacheKey = path + ".T405_ShopGoodClassManager";
            object objType = CreateObject(path, CacheKey);
            return (IT405_ShopGoodClassManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T406_ShopVIP接口对象。
        /// </summary>
        ///<returns>T406_ShopVIP接口对象</returns>
        public static IT406_ShopVIPManager Create_T406_ShopVIP()
        {
            string CacheKey = path + ".T406_ShopVIPManager";
            object objType = CreateObject(path, CacheKey);
            return (IT406_ShopVIPManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T501_Active接口对象。
        /// </summary>
        ///<returns>T501_Active接口对象</returns>
        public static IT501_ActiveManager Create_T501_Active()
        {
            string CacheKey = path + ".T501_ActiveManager";
            object objType = CreateObject(path, CacheKey);
            return (IT501_ActiveManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T502_ActiveRule接口对象。
        /// </summary>
        ///<returns>T502_ActiveRule接口对象</returns>
        public static IT502_ActiveRuleManager Create_T502_ActiveRule()
        {
            string CacheKey = path + ".T502_ActiveRuleManager";
            object objType = CreateObject(path, CacheKey);
            return (IT502_ActiveRuleManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T503_ActiveShop接口对象。
        /// </summary>
        ///<returns>T503_ActiveShop接口对象</returns>
        public static IT503_ActiveShopManager Create_T503_ActiveShop()
        {
            string CacheKey = path + ".T503_ActiveShopManager";
            object objType = CreateObject(path, CacheKey);
            return (IT503_ActiveShopManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T504_Preferential接口对象。
        /// </summary>
        ///<returns>T504_Preferential接口对象</returns>
        public static IT504_PreferentialManager Create_T504_Preferential()
        {
            string CacheKey = path + ".T504_PreferentialManager";
            object objType = CreateObject(path, CacheKey);
            return (IT504_PreferentialManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T801_New接口对象。
        /// </summary>
        ///<returns>T801_New接口对象</returns>
        public static IT801_NewManager Create_T801_New()
        {
            string CacheKey = path + ".T801_NewManager";
            object objType = CreateObject(path, CacheKey);
            return (IT801_NewManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T802_IndexFlash接口对象。
        /// </summary>
        ///<returns>T802_IndexFlash接口对象</returns>
        public static IT802_IndexFlashManager Create_T802_IndexFlash()
        {
            string CacheKey = path + ".T802_IndexFlashManager";
            object objType = CreateObject(path, CacheKey);
            return (IT802_IndexFlashManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9001_SearchKey接口对象。
        /// </summary>
        ///<returns>T9001_SearchKey接口对象</returns>
        public static IT9001_SearchKeyManager Create_T9001_SearchKey()
        {
            string CacheKey = path + ".T9001_SearchKeyManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9001_SearchKeyManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9002_Area接口对象。
        /// </summary>
        ///<returns>T9002_Area接口对象</returns>
        public static IT9002_AreaManager Create_T9002_Area()
        {
            string CacheKey = path + ".T9002_AreaManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9002_AreaManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9003_ImgDictionary接口对象。
        /// </summary>
        ///<returns>T9003_ImgDictionary接口对象</returns>
        public static IT9003_ImgDictionaryManager Create_T9003_ImgDictionary()
        {
            string CacheKey = path + ".T9003_ImgDictionaryManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9003_ImgDictionaryManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9003_SaleTotal接口对象。
        /// </summary>
        ///<returns>T9003_SaleTotal接口对象</returns>
        public static IT9003_SaleTotalManager Create_T9003_SaleTotal()
        {
            string CacheKey = path + ".T9003_SaleTotalManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9003_SaleTotalManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9004_PayType接口对象。
        /// </summary>
        ///<returns>T9004_PayType接口对象</returns>
        public static IT9004_PayTypeManager Create_T9004_PayType()
        {
            string CacheKey = path + ".T9004_PayTypeManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9004_PayTypeManager)objType;
        }


        /// <summary>
        /// 通过反射机制，实例化T9005_SorceTreadRule接口对象。
        /// </summary>
        ///<returns>T9005_SorceTreadRule接口对象</returns>
        public static IT9005_SorceTreadRuleManager Create_T9005_SorceTreadRule()
        {
            string CacheKey = path + ".T9005_SorceTreadRuleManager";
            object objType = CreateObject(path, CacheKey);
            return (IT9005_SorceTreadRuleManager)objType;
        }







      


      


     


        


      






    }
}
